{
    //类适配器
    //目标对象
    interface Target {
        request(): void
    }

    //适配者
    class Adaptee {
        constructor() { }
        //源角色，有自己的业务逻辑
        public specificRequest(): void {
            console.log('Adaptee :>> ');
        }
    }

    //类适配器（继承了源角色并实现了需要适配的目标接口）
    class Adapter extends Adaptee implements Target {
        constructor() {
            super()
        }
        request(): void {
            //关键代码，通过在实现的目标接口方法中调用源角色的方法实现适配
            super.specificRequest()
        }
    }

    //使用方法
    const target = new Adapter()
    target.request()
}


{
    //对象适配器
    //目标对象
    interface Target {
        request(): void
    }

    //被适配者
    class Adaptee {
        constructor() { }
        //源角色，拥有自己的业务逻辑
        public specificRequest(): void {
            console.log('Adaptee :>> ');
        }
    }

    //对象设配器（首先在构造函数中传入源角色，然后在需要适配的目标接口中调用该源角色的方法实现适配）
    class Adapter implements Target {
        private adaptee: Adaptee

    
        constructor(adaptee: Adaptee) {
            this.adaptee = adaptee
        }

        request(): void {
            //关键代码,调用传入的源角色的方法实现适配
            this.adaptee.specificRequest()
        }
    }
    //使用方法
    const target: Target = new Adapter(new Adaptee())
    target.request()
}


{
    //接口设配器
    //源接口
    interface Adaptee{
        operation1():void
        operation2():void
    }

    abstract class AbstractAdapter implements Adaptee{
        operation1(): void {
            
        }
        operation2(): void {
            
        }
    }

    class Employ extends AbstractAdapter{
        //重写方法
        public operation1(): void {
            
        }

        public operation2(): void {
            
        }
    }
}